#include"../source/server.hpp"

//单线程测试
// int main()
// {
//     Socket lis;
//     lis.CreateServer(9998);
//     while(1)
//     {
//         std::string ip;
//         uint64_t port;
//         int newfd=lis.Accept(port,ip);
//         std::cout<<newfd<<std::endl;
//         if(newfd<0)
//         {
//             continue;
//         }
//         std::cout << "新连接：fd=" << newfd << "，客户端IP=" << ip << "，端口=" << port << std::endl;
//         Socket cli_sock(newfd);
//         while (true) 
//         {
//             char buf[1024]={0};
//             int ret=cli_sock.Recv(buf,1023);
//             if(ret < 0)
//             {
//                 std::cout<<"接收错误，关闭连接"<<std::endl;
//                 break;
//             }
//             if(ret == 0)  // 客户端主动关闭连接（比如 Ctrl+C 退出）
//             {
//                 std::cout<<"客户端断开连接"<<std::endl;
//                 break;
//             }
//             std::cout<<"收到数据："<<buf<<std::endl;
//             cli_sock.Send(buf,ret);  // 回复数据
//         }
//          cli_sock.Close();  // 循环结束后再关闭连接
//     }
//     return 0;
// }
//多线程
// #include <thread>

// void ClientHandler(int newfd, const std::string& ip, uint64_t port) {
//     Socket cli_sock(newfd);
//     bool is_connected = true;
//     while (is_connected) {
//         char buf[1024] = {0};
//         int ret = cli_sock.Recv(buf, 1023);
//         if (ret < 0) {
//             std::cout << "[" << ip << ":" << port << "] 接收错误，关闭连接" << std::endl;
//             is_connected = false;
//         } else if (ret == 0) {
//             std::cout << "[" << ip << ":" << port << "] 客户端主动断开" << std::endl;
//             is_connected = false;
//         } else {
//             std::cout << "[" << ip << ":" << port << "] 收到数据：" << buf << std::endl;
//             cli_sock.Send(buf, ret);
//         }
//     }
//     cli_sock.Close();
// }

// int main() {
//     Socket lis;
//     lis.CreateServer(9998);
//     while (1) {
//         std::string ip;
//         uint64_t port;
//         int newfd = lis.Accept(port, ip);
//         if (newfd < 0) continue;

//         std::cout << "新连接 fd=" << newfd << "，客户端IP=" << ip << "，端口=" << port << std::endl;
//         // 为每个连接创建线程，分离线程（自动回收资源）
//         std::thread client_thread(ClientHandler, newfd, ip, port);
//         client_thread.detach();
//     }
//     return 0;
// }


//多路转接测试
// #include <sys/epoll.h>
// #include <vector>

// #define MAX_EVENTS 1024

// int main() {
//     Socket lis;
//     lis.CreateServer(9998);
//     int lis_fd = lis.Fd();

//     // 创建 epoll 实例
//     int epfd = epoll_create(1);
//     if (epfd < 0) {
//         perror("epoll_create failed");
//         return -1;
//     }

//     // 将监听套接字加入 epoll
//     struct epoll_event ev;
//     ev.events = EPOLLIN;
//     ev.data.fd = lis_fd;
//     epoll_ctl(epfd, EPOLL_CTL_ADD, lis_fd, &ev);

//     std::vector<struct epoll_event> events(MAX_EVENTS);
//     while (1) {
//         // 等待事件
//         int nfds = epoll_wait(epfd, events.data(), MAX_EVENTS, -1);
//         if (nfds < 0) {
//             perror("epoll_wait failed");
//             continue;
//         }

//         for (int i = 0; i < nfds; ++i) {
//             int fd = events[i].data.fd;
//             if (fd == lis_fd) {  // 监听套接字有新连接
//                 std::string ip;
//                 uint64_t port;
//                 int newfd = lis.Accept(port, ip);
//                 if (newfd < 0) continue;

//                 std::cout << "新连接 fd=" << newfd << "，客户端IP=" << ip << "，端口=" << port << std::endl;
//                 // 将新连接加入 epoll 监控
//                 ev.events = EPOLLIN;
//                 ev.data.fd = newfd;
//                 epoll_ctl(epfd, EPOLL_CTL_ADD, newfd, &ev);
//             } else {  // 通信套接字有数据可读
//                 Socket cli_sock(fd);
//                 char buf[1024] = {0};
//                 int ret = cli_sock.Recv(buf, 1023);
//                 if (ret < 0) {
//                     std::cout << "fd=" << fd << " 接收错误，关闭连接" << std::endl;
//                     epoll_ctl(epfd, EPOLL_CTL_DEL, fd, nullptr);
//                     cli_sock.Close();
//                 } else if (ret == 0) {
//                     std::cout << "fd=" << fd << " 客户端主动断开" << std::endl;
//                     epoll_ctl(epfd, EPOLL_CTL_DEL, fd, nullptr);
//                     cli_sock.Close();
//                 } else {
//                     std::cout << "fd=" << fd << " 收到数据：" << buf << std::endl;
//                     cli_sock.Send(buf, ret);
//                 }
//             }
//         }
//     }
//     close(epfd);
//     return 0;
// }
//没有EVENTLOOP的测试
// //单线程测试
// void HandleClose(Channel*channel)
// {
//     std::cout<<"close "<<channel->Fd()<<std::endl;
//     channel->Remove();
//     delete channel;
    
// }
// void HandleRead(Channel*channel)
// {
//     int fd=channel->Fd();
//     char buf[1024]={0};
//     int n=recv(fd,buf,1023,0);
//     if(n<0)
//     {
//         return HandleClose(channel);//关闭释放了，handelevent里的任意回调放在前面，不然channel关闭，段错误
//         ERR_LOG("RECV ERROR");
//     }
//     std::cout<<buf<<std::endl;
//     channel->EnableWrite();
// }
// void HandleWrite(Channel*channel)
// {
//     int fd=channel->Fd();
//     const char*data="i love cmz";
//     int n=send(fd,data,strlen(data),0);
//     if(n<0)
//     {
//         return HandleClose(channel);
//         ERR_LOG("SEND ERROR");
//     }
//     channel->DisableWrite();
// }
// void HandleError(Channel*channel)
// {
//     return HandleClose(channel);
// }
// void HandleEvent(Channel*channel)
// {
//     std::cout<<"有新事件"<<std::endl;
// }
// void Acceptor(Channel*listen_channel,Poller*poller)
// {
//     int fd=listen_channel->Fd();
//     int newfd=accept(fd,nullptr,nullptr);
//     if(newfd<0) {return ;}
//     Channel* channel=new Channel(newfd,poller);
//     channel->SetReadCallback(std::bind(HandleRead,channel));
//     channel->SetWriteCallback(std::bind(HandleWrite,channel));
//     channel->SetEventCallback(std::bind(HandleEvent,channel));
//     channel->SetCloseCallback(std::bind(HandleClose,channel));
//     channel->SetErrorCallback(std::bind(HandleError,channel));
//     channel->EnableRead();
// }
// int main()
// {
//     Socket lis;
//     lis.CreateServer(9998);
//     Poller poller;
//     Channel channel(lis.Fd(),&poller);
//     //为监听套接字，管理到来链接，创建channel并监控
//     channel.SetReadCallback(std::bind(Acceptor,&channel,&poller));
//     channel.EnableRead();
//     while(1)
//     {
//         std::vector<Channel*> active;
//         poller.Poll(&active);
//         for(auto&ch:active)
//         {
//             ch->HandleEvent();
//         }
//     }
//     return 0;
// }


// #include<stdlib.h>
// void HandleClose(Channel*channel)
// {
//     std::cout<<"超时10s关闭连接"<<std::endl;
//     std::cout<<"close "<<channel->Fd()<<std::endl;
//     channel->Remove();
//     delete channel;
// }
// void HandleRead(Channel*channel)
// {
//     int fd=channel->Fd();
//     char buf[1024]={0};
//     int n=recv(fd,buf,1023,0);
//     if(n<0)
//     {
//         return HandleClose(channel);//关闭释放了，handelevent里的任意回调放在前面，不然channel关闭，段错误
//         ERR_LOG("RECV ERROR");
//     }
//     std::cout<<buf<<std::endl;
//     channel->EnableWrite();
// }
// void HandleWrite(Channel*channel)
// {
//     int fd=channel->Fd();
//     const char*data="i love cmz";
//     int n=send(fd,data,strlen(data),0);
//     if(n<0)
//     {
//         return HandleClose(channel);
//         ERR_LOG("SEND ERROR");
//     }
//     channel->DisableWrite();
// }
// void HandleError(Channel*channel)
// {
//     return HandleClose(channel);
// }
// void HandleEvent(Channel*channel,Eventloop*loop,uint64_t id)
// {
//     std::cout<<"有新事件"<<std::endl;
//     loop->TimerRefresh(id);
// }
// void Acceptor(Channel*listen_channel,Eventloop*loop)
// {
//     int fd=listen_channel->Fd();
//     int newfd=accept(fd,nullptr,nullptr);
//     if(newfd<0) {return ;}
//     int timerid=rand()%1000;
//     Channel* channel=new Channel(newfd,loop);
//     channel->SetReadCallback(std::bind(HandleRead,channel));
//     channel->SetWriteCallback(std::bind(HandleWrite,channel));
//     channel->SetEventCallback(std::bind(HandleEvent,channel,loop,timerid));
//     channel->SetCloseCallback(std::bind(HandleClose,channel));
//     channel->SetErrorCallback(std::bind(HandleError,channel));
    
//     loop->TimerAdd(timerid,10,std::bind(HandleClose,channel));
//     channel->EnableRead();
// }
// int main()
// {
    // srand(time(nullptr));
    // Socket lis;
    // lis.CreateServer(9998);
    // Eventloop loop;
    // Channel channel(lis.Fd(),&loop);
    // //为监听套接字，管理到来链接，创建channel并监控
    // channel.SetReadCallback(std::bind(Acceptor,&channel,&loop));
    // channel.EnableRead();
    // while(1)
    // {
    //     loop.Start();
    // }
//     return 0;
// }


//管理所有的连接
std::unordered_map<uint64_t, PtrConnection> _conns;
uint64_t conn_id = 0;
Eventloop base_loop;
// std::vector<Threadloop> threads(2);
ThreadloopPool* thread_pool;

int i=0;


void ConnectionDestroy(const PtrConnection &conn) {
    _conns.erase(conn->Id());
} 
void OnConnected(const PtrConnection &conn) {
    DBG_LOG("NEW CONNECTION:%p", conn.get());
}
void OnMessage(const PtrConnection &conn, Buffer *buf) {
    DBG_LOG("%s", buf->ReadPosition());
    buf->ReadMoveOffset(buf->ReadAbleSize());
    std::string str = "Hello World";
    conn->Send(str.c_str(), str.size());
}


void  NewConnection(int newfd) 
{
    conn_id++;
    PtrConnection conn(new Connection(thread_pool->Nextloop(), conn_id, newfd));
    conn->SetMessageCallback(std::bind(OnMessage, std::placeholders::_1, std::placeholders::_2));
    conn->SetSrvClosedCallback(std::bind(ConnectionDestroy, std::placeholders::_1));
    conn->SetConnectedCallback(std::bind(OnConnected, std::placeholders::_1));
    conn->EnableInactiveRelease(10);//启动非活跃超时销毁
    conn->Established();//就绪初始化
    _conns.insert(std::make_pair(conn_id, conn));
    DBG_LOG("NEW ---------------");
}
int main()
{
    srand(time(nullptr));
    Acceptor lis(&base_loop,9998);
    thread_pool=new ThreadloopPool(&base_loop);
    thread_pool->SetThreadCount(4);// 设置 4 个从线程
    thread_pool->Create(); // 创建线程
    //为监听套接字，管理到来链接，创建channel并监控
    lis.SetAcceptCallback(std::bind(NewConnection,std::placeholders::_1));
    lis.Listen();
    while(1)
    {
        base_loop.Start();
    }
    return 0;
}